Aminet 1

home *** CD-ROM | disk | FTP | other *** search

/ Aminet 1 / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume91 / libraris / sregexp9 / part01 next >

Wrap

Internet Message Format | 1991-05-18 | 72.3 KB

Path: news.larc.nasa.gov!amiga-request From: amiga-request@ab20.larc.nasa.gov (Amiga Sources/Binaries Moderator) Subject: v91i107: sregexp.library 9.4 - a library for regular expressions, Part01/02 Reply-To: "J. Spencer" <bhgs@utcs.utoronto.ca> Newsgroups: comp.sources.amiga Message-ID: <comp.sources.amiga:v91i107@ab20.larc.nasa.gov> Date: 18 May 91 01:57:00 GMT Approved: tadguy@uunet.UU.NET (Tad Guy) X-Mail-Submissions-To: amiga@uunet.uu.net X-Post-Discussions-To: comp.sys.amiga.misc Submitted-by: "J. Spencer" <bhgs@utcs.utoronto.ca> Posting-number: Volume 91, Issue 107 Archive-name: libraries/sregexp-9.4/part01 [ includes uuencoded libraries ...tad ] 'sregexp.library' is a run time library of routines for doing wildcard pattern matching and wildcard path matching. It accepts a slight extension of the AmigaDOS wildcard syntax, including a not operator, and character sets. It has routines to test if a string matches a wildcard expression, and for scanning through all matches to a wildcarded AmigaDOS path. There are two nifty features to the path matching routines: '.../' means recursively scan all subdirectories, and may come anywhere in the path; and wildcards are allowed in the volume node part of the path! (DH?: would match all your hard drive partitions.) #!/bin/sh # This is a shell archive. Remove anything before this line, then unpack # it by saving it into a file and typing "sh file". To overwrite existing # files, type "sh file -c". You can also feed this as standard input via # unshar, or by typing "sh <file", e.g.. If this archive is complete, you # will see the following message at the end: # "End of archive 1 (of 2)." # Contents: BUGS_TO COPYRIGHT.NOTICE OVERVIEW clibrary.asm # compilation.notes dmakefile instillation.notes kludge.asm # revision.history spath.c sreg_version.c sreg_version.i sregexp.fd # sregexp.h sregexp.uu sregexp_protos.h sregexpbase.h sregexpbase.i # sregexps.uu sregexpsr.uu utils utils/bumprev.c utils/remlib.c # utils/try.c # Wrapped by tadguy@ab20 on Fri May 17 21:56:58 1991 PATH=/bin:/usr/bin:/usr/ucb ; export PATH if test -f 'BUGS_TO' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'BUGS_TO'\" else echo shar: Extracting \"'BUGS_TO'\" $94 characters$ sed "s/^X//" >'BUGS_TO' <<'END_OF_FILE' X XSend bug reports, comments, etc. to X X Jon Spencer. X X EMail: bhgs@gpu.utcs.utoronto.ca X END_OF_FILE if test 94 -ne `wc -c <'BUGS_TO'`; then echo shar: \"'BUGS_TO'\" unpacked with wrong size! fi # end of 'BUGS_TO' fi if test -f 'COPYRIGHT.NOTICE' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'COPYRIGHT.NOTICE'\" else echo shar: Extracting \"'COPYRIGHT.NOTICE'\" $1083 characters$ sed "s/^X//" >'COPYRIGHT.NOTICE' <<'END_OF_FILE' X X The library 'sregexp.library', and all sources and documentation X relating to it included in this distribution are Copyright (c) 1991, by X Jon Spencer. X X Permission is given to redistribute any part or all of this X distribution, either modified or unmodified, PROVIDED THAT: X - the distribution is on a not-for-profit basis, X - this copyright notice is included in the distribution, X - and if a modified version is distributed, clear indication X that it is modified is included. X X All other rights are reserved by the author, Jon Spencer. X X X(disclaimer borrowed, somewhat modified, from the DICE distribution) X X PROGRAM DISCLAIMER: THE LIBRARY IS PROVIDED "AS IS" WITHOUT WARRANTY OF X ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, X THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR X PURPOSE. THE ENTIRE RISK AS TO THE RESULTS AND PERFORMANCE OF ANY X PROGRAM IS ASSUMED BY YOU. Should the program prove defective, you X assume the entire cost of all necessary servicing, repair, or X correction. X END_OF_FILE if test 1083 -ne `wc -c <'COPYRIGHT.NOTICE'`; then echo shar: \"'COPYRIGHT.NOTICE'\" unpacked with wrong size! fi # end of 'COPYRIGHT.NOTICE' fi if test -f 'OVERVIEW' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'OVERVIEW'\" else echo shar: Extracting \"'OVERVIEW'\" $622 characters$ sed "s/^X//" >'OVERVIEW' <<'END_OF_FILE' X X'sregexp.library' is a run time library of routines for doing wildcard Xpattern matching and wildcard path matching. It accepts a slight extension Xof the AmigaDOS wildcard syntax, including a not operator, and character Xsets. It has routines to test if a string matches a wildcard expression, Xand for scanning through all matches to a wildcarded AmigaDOS path. There Xare two nifty features to the path matching routines: '.../' means Xrecursively scan all subdirectories, and may come anywhere in the path; and Xwildcards are allowed in the volume node part of the path! (DH?: would Xmatch all your hard drive partitions.) END_OF_FILE if test 622 -ne `wc -c <'OVERVIEW'`; then echo shar: \"'OVERVIEW'\" unpacked with wrong size! fi # end of 'OVERVIEW' fi if test -f 'clibrary.asm' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'clibrary.asm'\" else echo shar: Extracting \"'clibrary.asm'\" $11630 characters$ sed "s/^X//" >'clibrary.asm' <<'END_OF_FILE' X X;************************************************************************** X;* * X;* sregexp.library -- pattern matching run time library. * X;* * X;* * X;* Startup module: this is heavily copied from the sample.library * X;* in the RKM includes and autodocs. * X;* This also relies on some features of dice (in particular, registered * X;* args and features of the linker.) Be carefull if you make it with * X;* something else. * X;* * X;* Created: April 20, 1991 * X;* * X;************************************************************************** X X CODE sregexp.start X X INCLUDE "sregexpbase.i" X INCLUDE "exec/initializers.i" X INCLUDE "libraries/dos.i" X INCLUDE "exec/resident.i" X INCLUDE "exec/lists.i" X INCLUDE "exec/alerts.i" X INCLUDE "sreg_version.i" X X;-------------------------------------------------------------------- X; some generally usefull macros hiding _LVO's X;-------------------------------------------------------------------- XCALLSYS macro X jsr _LVO\1(a6) X endm X XXLIB macro X xref _LVO\1 X endm X X;-------------------------------------------------------------------- X; Declare the library calls I use. The _LVO's are brought in X; from amiga.lib X;-------------------------------------------------------------------- X XLIB OpenLibrary X XLIB CloseLibrary X XLIB Alert X XLIB FreeMem X XLIB Remove X X;------ defined in Amiga.lib ------ X xref _AbsExecBase X X;------ defined in the c source, the id string of my library. ------ X xref _idString X X X X X;-------------------------------------------------------------------- X; Make some stuff visible for debuging. X;-------------------------------------------------------------------- X xdef Init X xdef EndCode X xdef RomTag X xdef funcTable X xdef dataTable X xdef InitRoutine X X xdef Open X xdef Close X xdef Expunge X xdef Reserved X X;-------------------------------------------------------------------- X; The links to the c code are in the file kludge.asm, because the X; assembler I use doesn't like to make symbols starting with a @. X; But thats what DICE starts it's regargs routines with, so... X; I make the links with das, which comes with dice. X; X; my library routines X;-------------------------------------------------------------------- X xref parsesregexp X xref freesregexp X xref matchsregexp X xref matchnsregexp X xref iswild X xref anchorpath X xref nextfile X xref buildpath X xref freespathinfo X X X X X X************************************************************************ X* Ok, so much for the preamble, we can actually start to generate * X* some code now. The very first thing we should do is return an * X* error if someone tries to run us like a program, seeing as we * X* will be a perfectly legal AmigaDos load module. * X************************************************************************ X XStart: X moveq.l #-1,d0 X rts X X X;-------------------------------------------------------------------- X; Ok, here's what exec is going to look for to tell it that we are X; a library. X;-------------------------------------------------------------------- XRomTag: X dc.w RTC_MATCHWORD ; magic X dc.l RomTag ; pointer back to magic X dc.l EndCode ; keep looking from here X dc.b RTF_AUTOINIT ; yes, autoinit me. X dc.b VERSION ; version number X dc.b NT_LIBRARY ; I'm a library X dc.b 0 ; no priority (typical) X dc.l sregexpname ; I have a name X dc.l _idString ; let's see some ID X dc.l Init ; start me up X X X;-------------------------------------------------------------------- X; Ok, heres the table of 4 vectors exec is going to look for X; to autoinit me. X; X; We are word alligned here. X;-------------------------------------------------------------------- XInit: X dc.l SregExpBase_SIZE ; size of library structure X dc.l funcTable ; table of all my routines. X dc.l dataTable ; LibStructure init data X dc.l InitRoutine ; Where to start me. X X X;-------------------------------------------------------------------- X; This is the list of functions in my library. X;-------------------------------------------------------------------- XfuncTable: X dc.l Open X dc.l Close X dc.l Expunge X dc.l Reserved X X; my own little gems. X dc.l parsesregexp X dc.l freesregexp X dc.l matchsregexp X dc.l matchnsregexp X dc.l iswild X dc.l anchorpath X dc.l nextfile X dc.l buildpath X dc.l freespathinfo X dc.l -1 ; end of the list. X X;-------------------------------------------------------------------- X; heres the stuff to initialise my Library structure. X;-------------------------------------------------------------------- XdataTable: X INITBYTE LN_TYPE,NT_LIBRARY X INITLONG LN_NAME,sregexpname X INITBYTE LIB_FLAGS,LIBF_SUMUSED|LIBF_CHANGED X INITWORD LIB_VERSION,VERSION X INITWORD LIB_REVISION,REVISION X INITLONG LIB_IDSTRING,_idString X dc.l 0 X X X X******************************************************************* X* Ok, so now were really ready to get cooking. * X* This routine is called when the library is first linked into * X* the exec LibList. The Library structure has already been * X* initialised as per the dataTable instructions. * X* * X* When called, d0 has our library base and the segment list is * X* pointed to by a0; a6 is a pointer to SysBase. * X******************************************************************* X XInitRoutine: X move.l a4,-(sp) ; put the lib pointer X move.l d0,a4 ; in a convinient place X X move.l a6,sb_SysBase(a4) ; save SysBase X move.l a0,sb_SegList(a4) ; save our seglist X X lea.l dosname(pc),a1 ; try and open up X moveq.l #0,d0 ; dos.library X CALLSYS OpenLibrary X X move.l d0,sb_DOSBase(a4) ;save dos X bne.s 1$ X X X ALERT AG_OpenLib|AO_DOSLib ; couldn't get dos!!! X X;------- That's all there is to do. -------- X1$ X move.l a4,d0 X move.l (sp)+,a4 X rts X X X X*********************************************************************** X* So good so far. Now come the 4 standard library routines that * X* every good library must have. Each of these (in fact all of the * X* library calls) comes with the pointer to our library base in a6. * X*********************************************************************** X X;---------------------------------------------------------------------- X; To open the library, all we have to do is up the count of current X; users and reset the delayed expunge flag. This returns the library X; pointer on d0 if we successfully opened (which is always the case). X;---------------------------------------------------------------------- XOpen: X addq.w #1,LIB_OPENCNT(a6) X bclr #LIBB_DELEXP,LIB_FLAGS(a6) X move.l a6,d0 X rts X X X X X;---------------------------------------------------------------------- X; When we close the library, we decrease the count of current X; users. If this has reached zeros, then we check the delayed X; expunge flag and clean up if it is set. X; If this routine returns 0 then that's that. If the return value X; is non-zero, it should be the segment pointer passed to the X; initialization routine, so we can be unloaded. X;---------------------------------------------------------------------- XClose: X ;--- set up the return value, which will be altered --- X ;--- if we decide to do a delayed expunge. --- X moveq.l #0,d0 X subq.w #1,LIB_OPENCNT(a6) X bne.s 1$ X btst #LIBB_DELEXP,LIB_FLAGS(a6) X beq.s 1$ X X; --- take a shortcut into the Expunge routine that doesn't --- X; --- redo the tests we just did. --- X bsr.s ReallyExpunge X X1$ X; --- at this point, d0 is zero if we didn't expunge, otherwise --- X; --- it the address of our segment list. --- X rts X X X X;---------------------------------------------------------------------- X; Ok, so now we want to try to unload. First check if there X; are still any current openers, if so, just set the delayed X; expunge flag, and we'll go away when everyone closes us. X; Otherwise, clean up my resources and return the seg list to X; be unloaded X;---------------------------------------------------------------------- XExpunge: X tst.w LIB_OPENCNT(a6) X beq.s ReallyExpunge X X bset #LIBB_DELEXP,LIB_FLAGS(a6) X moveq.l #0,d0 ;don't unload me please X rts X XReallyExpunge: X movem.l d2/a5,-(sp) X move.l a6,a5 X move.l sb_SysBase(a5),a6 X X move.l sb_SegList(a5),d2 ;save seglist. X X move.l a5,a1 ;remove the library X REMOVE ;from the system list X X move.l sb_DOSBase(a5),a1 X CALLSYS CloseLibrary ;close dos. X X moveq.l #0,d0 X move.l a5,a1 X move.w LIB_NEGSIZE(a5),d0 X sub.l d0,a1 X add.w LIB_POSSIZE(a5),d0 X X CALLSYS FreeMem ;free our library base. X X move.l d2,d0 ;unload us. X X movem.l (sp)+,d2/a5 X rts X X X;---------------------------------------------------------------------- X; This is the reserved vector. Just return 0. X;---------------------------------------------------------------------- XReserved: X moveq.l #0,d0 X rts X X X X********************************************************************** X* That's all of the standard stuff. As discussed above, the links * X* to the c code are in the file kludge.asm * X********************************************************************** X X X X X X X X;---------------------------------------------------------------------- X; Here are some stings used in the above. I put them at the end so X; so I don't have to worry about alignment. X;---------------------------------------------------------------------- Xdosname DOSNAME X Xsregexpname SREGEXPNAME X X;---------------------------------------------------------------------- X; The end of the code, where exec can start looking for more RomTag X; structures if it wants to. X;---------------------------------------------------------------------- X EVEN XEndCode: X X X X X X********************************************************************** X* * X* Now comes the clever part. Dice (and the others, I think) * X* references there global data from register a4. What I do * X* to have easy access to the Library structure data from the * X* c code, is transfer a6 to a4 on each library call and then * X* define the various things I want to access as offsets to * X* this, in effect, tricking dice into thinking they're global * X* variables. The real benifit of this is I don't need my own * X* custom links to the Exec and DOS library routines, because * X* there exists perfectly valid global variables SysBase and * X* DosBase. * X* * X********************************************************************** X X DATA data X X;--------------------------------------------------------------------- X; This one is a little funny, it is the actual instance of the X; structure, and not a pointer to it. It should be declared in X; the c code as 'extern struct SregExpBase SregExpBase;' and then X; referenced with the '.' and not the '->'. This may not work X; I haven't tried it yet. X;---------------------------------------------------------------------- X_SregExpBase equ 0 X xdef _SregExpBase X X;--- These are perfectly ordinary pointers --- X_SysBase equ sb_SysBase X xdef _SysBase X X_DOSBase equ sb_DOSBase X xdef _DOSBase X X end X END_OF_FILE if test 11630 -ne `wc -c <'clibrary.asm'`; then echo shar: \"'clibrary.asm'\" unpacked with wrong size! fi # end of 'clibrary.asm' fi if test -f 'compilation.notes' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'compilation.notes'\" else echo shar: Extracting \"'compilation.notes'\" $1301 characters$ sed "s/^X//" >'compilation.notes' <<'END_OF_FILE' X X X As it says in various places in the source, this whole thing is kind X of DICE dependent. If you know what you are doing you should be X able to get it to compile under anything. X X The c source was not written with an eye to portability, but I don't X think it is too bad. X X To make under another compiler you will almost definitely have to change X the file kludge.asm, were the jump vectors into the code are. Most X likely you'll have to take the register parameters and stuff X them onto the stack. X X The easiest thing to do is just type 'dmake install' and trust X my compilations. X X PLEASE do not distribute modified versions, and if you do make sure X the copyright notice is left intact AND you state clearly it is X a modified version. X X X Note that I made everything under 1.3 (I don't have 2.0). There X are a few things to consider, however. I have made my own 1.3 version X of the 'clib' directory, which is new to 2.0. This also allowed X me to make my own 1.3 registered args amigasr13.lib linker X library. If you want to remake this under 1.3 with dice, you will X have to either come up with these yourself, or modify kludge.asm X to stuff the parameters on to the stack. Under 2.0 everything should X go, but no guarantees. X END_OF_FILE if test 1301 -ne `wc -c <'compilation.notes'`; then echo shar: \"'compilation.notes'\" unpacked with wrong size! fi # end of 'compilation.notes' fi if test -f 'dmakefile' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'dmakefile'\" else echo shar: Extracting \"'dmakefile'\" $1467 characters$ sed "s/^X//" >'dmakefile' <<'END_OF_FILE' X XOD = OBJS:sreg/ X XCSRC = sregexp.c sreg_version.c spath.c XCOBJ = $(CSRC:"*.c":"$(OD)*.o") XOBJ = $(OD)clibrary.o $(OD)kludge.o $(COBJ) XJUNK = utils/try utils/remlib utils/bumprev XJUNKSRC = $(JUNK:"*":"*.c") X XLINKLIBS = amigasr13.lib cr.lib X XLIBRARY = sregexp.library X XCOPTS = -c -mRR -mS -proto X#COPTS = -c -mRR -mS -proto -D __DEBUG__ X Xall : sregexpsr.lib sregexps.lib $(JUNK) $(LIBRARY) X X$(JUNK) : $(JUNKSRC) X dcc -mRR -r -lsregexpsr -o %(left) %(right) X X$(LIBRARY) : $(OBJ) X -Delete >NIL: %(left) X dlink -o %(left) $(OBJ) $(LINKLIBS) X utils/remlib $(LIBRARY) X Protect %(left) -E X X$(OD)clibrary.o : clibrary.asm sreg_version.i X -Delete >NIL: %(left) X a68k -q -iAINC: -o%(left) clibrary.asm X X$(OD)kludge.o : kludge.asm X -Delete >NIL: %(left) X das -o%(left) %(right) X X$(COBJ) : $(CSRC) X -Delete >NIL: %(left) X dcc $(COPTS) -o %(left) %(right) X Xsregexpsr.lib : sregexp.fd sregexp_protos.h X -Delete >NIL: %(left) X fdtolib -mr sregexp.fd -o %(left) -h sregexp_protos.h X Xsregexps.lib : sregexp.fd X -Delete >NIL: %(left) X fdtolib sregexp.fd -o %(left) X Xsreg_version.i : $(CSRC) clibrary.asm kludge.asm utils/bumprev X utils/bumprev X touch sreg_version.i X Xclean : X -Delete $(JUNK) X -Delete $(OBJ) X -Delete sregexpsr.lib sregexps.lib X Xinstall : X Copy $(LIBRARY) Libs: X Copy sregexpbase.h dinclude:pd/libraries X Copy sregexp_protos.h dinclude:pd/clib X Copy sregexps.lib dlib: X Copy sregexpsr.lib dlib: END_OF_FILE if test 1467 -ne `wc -c <'dmakefile'`; then echo shar: \"'dmakefile'\" unpacked with wrong size! fi # end of 'dmakefile' fi if test -f 'instillation.notes' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'instillation.notes'\" else echo shar: Extracting \"'instillation.notes'\" $757 characters$ sed "s/^X//" >'instillation.notes' <<'END_OF_FILE' X X X If you have dmake, then just change to this directory and X type 'dmake install' and all of the files will be copied to X the appropriate place (if not you can edit the dmake file) X X If not, heres where they should go: X X sregexp.library should be copied to LIBS: X X sregexps.lib should go to DLIB: If you use a different X sregexpsr.lib compiler, you will have to use whatever X utility exists to turn the fd file into X your kind of library. X X sregexpbase.h should go in the 'libraries' directory, X where ever you keep your Amiga include X files. X X sregexp_protos.h Under 2.0 this goes in 'clib' I compiled X everything under 1.3, but I have a fake X 1.3 clib directory of my own making. X Basically put it where you want. X END_OF_FILE if test 757 -ne `wc -c <'instillation.notes'`; then echo shar: \"'instillation.notes'\" unpacked with wrong size! fi # end of 'instillation.notes' fi if test -f 'kludge.asm' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'kludge.asm'\" else echo shar: Extracting \"'kludge.asm'\" $1876 characters$ sed "s/^X//" >'kludge.asm' <<'END_OF_FILE' X X;------------------------------------------------------------------- X; Here are the links to the c code. Anything that dice can't make X; registered arguement versions of would have to stick the stuff onto the X; stack. Note that the fd file and dice must both have the same X; idea of what gets passed in what. I will perhaps automate that X; one day. For now just be carefull. X;------------------------------------------------------------------- X X section kludge,code X X xdef parsesregexp X xref @parsesregexp Xparsesregexp: X move.l a4,-(sp) X move.l a6,a4 X jsr @parsesregexp(pc) X move.l (sp)+,a4 X rts X X xdef freesregexp X xref @freesregexp Xfreesregexp: X move.l a4,-(sp) X move.l a6,a4 X jsr @freesregexp(pc) X move.l (sp)+,a4 X rts X X xdef matchsregexp X xref @matchsregexp Xmatchsregexp: X move.l a4,-(sp) X move.l a6,a4 X jsr @matchsregexp(pc) X move.l (sp)+,a4 X rts X X xdef matchnsregexp X xref @matchnsregexp Xmatchnsregexp: X move.l a4,-(sp) X move.l a6,a4 X jsr @matchnsregexp(pc) X move.l (sp)+,a4 X rts X X xdef iswild X xref @iswild Xiswild: X move.l a4,-(sp) X move.l a6,a4 X jsr @iswild(pc) X move.l (sp)+,a4 X rts X X xdef anchorpath X xref @anchorpath Xanchorpath: X move.l a4,-(sp) X move.l a6,a4 X jsr @anchorpath(pc) X move.l (sp)+,a4 X rts X X xdef nextfile X xref @nextfile Xnextfile: X move.l a4,-(sp) X move.l a6,a4 X jsr @nextfile(pc) X move.l (sp)+,a4 X rts X X xdef buildpath X xref @buildpath Xbuildpath: X move.l a4,-(sp) X move.l a6,a4 X jsr @buildpath(pc) X move.l (sp)+,a4 X rts X X xdef freespathinfo X xref @freespathinfo Xfreespathinfo: X move.l a4,-(sp) X move.l a6,a4 X jsr @freespathinfo(pc) X move.l (sp)+,a4 X rts X X end END_OF_FILE if test 1876 -ne `wc -c <'kludge.asm'`; then echo shar: \"'kludge.asm'\" unpacked with wrong size! fi # end of 'kludge.asm' fi if test -f 'revision.history' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'revision.history'\" else echo shar: Extracting \"'revision.history'\" $468 characters$ sed "s/^X//" >'revision.history' <<'END_OF_FILE' X X version 9.x X First version ready for general release, everything seems X to work ok. X X versions 4.0 - 8.xx X Various steps on the long road to getting the path matching X routines to actually work. X X version 2.0 - 3.xx X Porting of the pattern matching routines from a link time X library to a run time library. X X version 1.xx X Figuring out how to make a @&*! Amiga run time library X go. WHY DOES IT GURU WHEN I EXPUNGE, AHHHHH! Well X it worked in the end. END_OF_FILE if test 468 -ne `wc -c <'revision.history'`; then echo shar: \"'revision.history'\" unpacked with wrong size! fi # end of 'revision.history' fi if test -f 'spath.c' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'spath.c'\" else echo shar: Extracting \"'spath.c'\" $12546 characters$ sed "s/^X//" >'spath.c' <<'END_OF_FILE' X X/********************************************************************** X * This is the stuff for matching to a wildcarded path. see the docs * X * * X * * X * Copyright (c) 1991 by Jon Spencer. * X * * X * Revision history: * X * May 10, 1991 First version basically completed * X * * X **********************************************************************/ X X#include "sregexp.h" X Xextern struct DosLibrary *DOSBase; X X#ifdef __DEBUG__ Xvoid puts(char *); Xvoid printf(char *, ...); X#endif X X#define ROOT ((struct RootNode *)DOSBase->dl_Root) X#define INFO ((struct DosInfo *)ROOT->rn_Info<<2) X#define DEVC(a) ((struct DeviceList *)a<<2) X Xstruct SpathInfo * Xanchorpath(anc,wld) Xchar *anc,*wld; X/* This is routine sets everything up for matching wildcard paths. X It does the expansion of any wildcards in the volume node part X of the path, if any where specified, and gets ready to roll. */ X{ X struct SpathInfo *spi; X struct SpathNode *spn; X BPTR lock; X register char *q; X char *node,*p,c; X struct DeviceList *dvc; X struct SregExp *pat; X X X if (!(spi = getmem(sizeof(struct SpathInfo)))) { X report(MEM_ERROR); X return NULL; X } X NewList((struct List *)spi); X X for (q = wld; *q != ':' && *q != '/' && *q; q++) ; X X if (*q == ':') { X if (!(node = getmem(q - wld + 1))) { X report(MEM_ERROR); X FreeMem(spi,sizeof(struct SpathInfo)); X FreeMem(spi,sizeof(struct SpathInfo)); X return NULL; X } X for (q = wld, p = node; *q != ':'; ) X *p++ = *q++; X *p = 0; X X pat = parsesregexp(node); X FreeMem(node,strlen(node)+1); X if (!pat) { X FreeMem(spi,sizeof(struct SpathInfo)); X return NULL; X } X X /* Check if there is no path to parse */ X if (*(q+1)) { X if (!(spi->spi_SregList = parsepath(q+1))) { X freesregexp(pat); X FreeMem(spi,sizeof(struct SpathInfo)); X return NULL; X } X } else X spi->spi_SregList = NULL; X X X if (pat->sre_Type == SRP_NULL) { /* check for paths matching ":..." */ X X if (!(lock = Lock(anc,SHARED_LOCK))) { X freesregexp(pat); X freespathinfo(spi); X return NULL; X } X if (!(node = getmem(2))) { X report(MEM_ERROR); X UnLock(lock); X freesregexp(pat); X freespathinfo(spi); X return NULL; X } X node[0] = ':'; X node[1] = 0; X if (!(spn = makespathnode(lock,node,spi->spi_SregList))) { X UnLock(lock); X FreeMem(node,2); X freesregexp(pat); X freespathinfo(spi); X return NULL; X } X spn->spn_NodeName = node; X AddTail((struct List *)spi,(struct Node *)spn); X UnLock(lock); X } else { X for (dvc = DEVC(INFO->di_DevInfo); dvc; dvc = DEVC(dvc->dl_Next)) { X p = (char *)dvc->dl_Name<<2; X if (matchnsregexp(p+1,pat,FALSE,*p)) { X if (!(node = getmem(*p+2))) { X report(MEM_ERROR); X freesregexp(pat); X freespathinfo(spi); X return NULL; X } X for (c = *p++, q = node; c > 0; c--) X *q++ = *p++; X *q++ = ':'; X *q = 0; X if (dvc->dl_Type == DLT_DEVICE) { X lock = Lock(node,SHARED_LOCK); /* ignore non-filesystem devices */ X if (!lock) X continue; X UnLock(lock); X } X if (!(spn = makespathnode(NULL,node,spi->spi_SregList))) { X FreeMem(node,strlen(node)+1); X X freespathinfo(spi); X return NULL; X } X spn->spn_NodeName = node; X AddTail((struct List *)spi,(struct Node *)spn); X } X } X } X freesregexp(pat); X } else { X /* check if there is any path to parse */ X if (*wld) { X if (!(spi->spi_SregList = parsepath(wld))) { X FreeMem(spi,sizeof(struct SpathInfo)); X return NULL; X } X } else X spi->spi_SregList = NULL; X X if (!(spn = makespathnode(NULL,anc,spi->spi_SregList))) X freespathinfo(spi); X AddTail((struct List *)spi,(struct Node *)spn); X } X return spi; X} X X#undef ROOT X#undef INFO X#undef DEVC X Xstruct SregList * Xparsepath(wld) Xchar *wld; X/* This routine takes a wildcarded path and turns it into a singly X linked list of SregExp structures, one node for each path element. */ X{ X char *q,*p,*cp,c = 1,recurse; X struct SregExp *sre; X struct SregList *srl,*srr = NULL; X X if (!(cp = getmem(strlen(wld)+1))) { X report(MEM_ERROR); X return NULL; X } X strcpy(cp,wld); X X q = cp; X while (*q && c) { X if (strncmp(q,".../",4) == 0) { X recurse = SRF_RECURSE; X q += 4; X } else X recurse = 0; X p = q; X while (*q && *q != '/') q++; X c = *q; X *q = 0; X if (!(sre = parsesregexp(p))) X goto bad; X sre->sre_Flag |= recurse; X *q++ = c; X if (!srr) { X if (!(srl = srr = getmem(sizeof(struct SregList)))) { X report(MEM_ERROR); X goto bad; X } X } else { X if (!(srl = (srl->srl_next = getmem(sizeof(struct SregList))))) { X report(MEM_ERROR); X goto bad; X } X } X srl->srl_next = NULL; X srl->srl_sreg = sre; X } X if (c == '/') /* If path ends in a / then just take dirs */ X srl->srl_sreg->sre_Flag |= SRF_JUSTDIRS; X X FreeMem(cp,strlen(cp)+1); X return srr; X Xbad: X if (sre) X freesregexp(sre); X FreeMem(cp,strlen(cp)+1); X X while (srl) { X if (srl->srl_sreg) X freesregexp(srl->srl_sreg); X FreeMem(srl,sizeof(struct SregList)); X srl = srl->srl_next; X } X return NULL; X} X Xstruct SpathNode * Xmakespathnode(lock,file,sreg) XBPTR lock; Xchar *file; Xstruct SregList *sreg; X/* This routine makes a new node to be linked into the list of current X directory locks, basically */ X{ X struct SpathNode *spn; X BPTR cdir; X X X if (!(spn = getmem(sizeof(struct SpathNode)))) { X report(MEM_ERROR); X return NULL; X } X if (lock) X cdir = CurrentDir(lock); X if (!(spn->spn_Lock = Lock(file,SHARED_LOCK))) { X FreeMem(spn,sizeof(struct SpathNode)); X return NULL; X } X spn->spn_SregList = sreg; X if (!(Examine(spn->spn_Lock,&spn->spn_FIB))) { X UnLock(spn->spn_Lock); X FreeMem(spn,sizeof(struct SpathNode)); X return NULL; X } X spn->spn_Flags = 0; X spn->spn_NodeName = NULL; X if (lock) X CurrentDir(cdir); X X return spn; X} X X X X#define FILENAME (spn->spn_FIB.fib_FileName) X#define NEXTPATH (spn->spn_SregList->srl_next) X#define THISPATH (spn->spn_SregList) X#define LOCK (spn->spn_Lock) X#define FIB (spn->spn_FIB) X#define SREG (spn->spn_SregList->srl_sreg) X#define ISDIR (FIB.fib_DirEntryType > 0) X#define ISRECURSE (SREG->sre_Flag & SRF_RECURSE) X#define ISDONEONCE (spn->spn_Flags & SPF_DONEONCE) X#define ISJUSTDIRS (SREG->sre_Flag & SRF_JUSTDIRS) X#define WANTIT (ISDIR ? dirs >= 0 : !ISJUSTDIRS && dirs <= 0) X#define SIGBREAKF_ANY (SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | SIGBREAKF_CTRL_E | SIGBREAKF_CTRL_F) X Xint Xnextfile(spi,buf,len,dirs) Xstruct SpathInfo *spi; Xchar *buf; Xint len,dirs; X/* This routine is a mess. It jumps all over the place and is generally X hard to follow. The basic idea behind it is to implement recursion, X but without using the stack. Basically the linked list of SpathNode X structures, anchored in the SpathInfo structure works as our stack X for us. "Why not just use the stack?" you ask. Well, unfortunately, X we have to return in the middle of the scan, each time a new match X is found. This would mean unrolling all of the stack that defines X how far through the search we are to get back to the return address. X By using the linked list of SpathInfo structures, we can preserve X the state of the 'stack' betweem calls. */ X{ X struct SpathNode *spn; X X Xtry_again: X X if (SetSignal(0,0) & SIGBREAKF_ANY) X return SPE_SIGBREAK; X X spn = spi->spi_TailPred; X X /* check if we're done. */ X if (!spn->spn_Pred) { X report(ERROR_NO_MORE_ENTRIES); X return SPE_ALL_DONE; X } X X /* check if we're at the end of the path: used to match just nodes.*/ X if (!THISPATH) { X if (ISDONEONCE) X goto pop; X X spn->spn_Flags |= SPF_DONEONCE; X X if (dirs >= 0) { X return buildpath(spi,buf,len); X } else X goto pop; X } X X /* check if we set a delayed decend */ X if (spn->spn_Flags & SPF_DECEND) X goto decend; X X /* check if it matches the null string, ie parent dir */ X if (SREG->sre_Type == SRP_NULL) { X X /* Check if its done or there is no parent. */ X if (ISDONEONCE || !ParentDir(LOCK)) X goto pop; X X spn->spn_Flags |= SPF_DONEONCE; /* Mark it as done. */ X X /* mark it as parent match for buildpath */ X spn->spn_Flags |= SPF_NEXTPARENT; X X if (!(spn = makespathnode(LOCK,"/",NEXTPATH))) X return SPE_ERROR; X AddTail((struct List *)spi,(struct Node *)spn); X goto try_again; X } X X /* Check if we can do it quickly */ X if ((SREG->sre_Type == SRP_STRING || X SREG->sre_Type == SRP_ONECHAR) && !ISRECURSE) { X BPTR cdir,lock; X X /* Have we already done it? */ X if (ISDONEONCE) X goto pop; X X /* Mark it as done. */ X spn->spn_Flags |= SPF_DONEONCE; X X cdir = CurrentDir(LOCK); X if (SREG->sre_Type == SRP_STRING) X lock = Lock(SREG->sre_Data.string,SHARED_LOCK); X else { X char n[2]; X X n[0] = SREG->sre_Data.onechar; X n[1] = 0; X lock = Lock(n,SHARED_LOCK); X } X CurrentDir(cdir); X if (!lock) X goto pop; X if (!Examine(lock,&FIB)) { X UnLock(lock); X return SPE_ERROR; X } X UnLock(lock); X X if (!NEXTPATH) { X if (WANTIT) X return buildpath(spi,buf,len); X else X goto pop; X } X if (ISDIR) { X if (!(spn = makespathnode(LOCK,FILENAME,NEXTPATH))) { X return SPE_ERROR; X } X AddTail((struct List *)spi,(struct Node *)spn); X goto try_again; X } X goto pop; X } X X while (ExNext(LOCK,&FIB)) { X if (SetSignal(0,0) & SIGBREAKF_ANY) X return SPE_SIGBREAK; X X if (matchsregexp(FILENAME,SREG,FALSE)) { X if (ISDIR && ISRECURSE) X spn->spn_Flags |= SPF_DECEND; X if (!NEXTPATH) { X if (WANTIT) X return buildpath(spi,buf,len); X } else if (ISDIR) { X if (!(spn = makespathnode(LOCK,FILENAME,NEXTPATH))) { X return SPE_ERROR; X } X AddTail((struct List *)spi,(struct Node *)spn); X goto try_again; X } X } X if (ISDIR && ISRECURSE) { Xdecend: X spn->spn_Flags &= ~SPF_DECEND; X if (!(spn = makespathnode(LOCK,FILENAME,THISPATH))) { X return SPE_ERROR; X } X AddTail((struct List *)spi,(struct Node *)spn); X goto try_again; X } X } X X if (IoErr() != ERROR_NO_MORE_ENTRIES) X return SPE_ERROR; X Xpop: X RemTail((struct List*)spi); X freespathnode(spn); X goto try_again; X} X X#undef FILENAME X#undef NEXTPATH X#undef THISPATH X#undef LOCK X#undef FIB X#undef SREG X#undef ISDIR X#undef ISRECURSE X#undef ISDONEONCE X#undef ISJUSTDIRS X#undef WANTIT X X Xint Xbuildpath(spi,buf,len) Xstruct SpathInfo *spi; Xchar *buf; Xint len; X/* This routine turns the current 'stack' of SpathNode structures into X a file name the AmigaDOS will like. */ X{ X struct SpathNode *spn = spi->spi_Head; X int i = 0; X char *q; X X if (len < 1) X return SPE_BUFF_FULL; X X if (spn->spn_Succ && spn->spn_NodeName) { X while (spn->spn_Succ->spn_Succ && spn->spn_Succ->spn_NodeName) { X spn = spn->spn_Succ; X } X } X X if (q = spn->spn_NodeName) { X while (*q && i < len) X buf[i++] = *q++; X if (i >= len) X return SPE_BUFF_FULL; X } X while (spn->spn_Succ) { X if (spn->spn_Flags & SPF_NEXTPARENT) { X buf[i++] = '/'; X if (i >= len) X return SPE_BUFF_FULL; X } else { X q = spn->spn_FIB.fib_FileName; X while (*q && i < len) X buf[i++] = *q++; X if (i >= len) X return SPE_BUFF_FULL; X if (spn->spn_Succ->spn_Succ || X spn->spn_SregList->srl_sreg->sre_Flag & SRF_JUSTDIRS) { X buf[i++] = '/'; X if (i >= len) X return SPE_BUFF_FULL; X } X } X spn = spn->spn_Succ; X } X X buf[i] = 0; X return i; X} X Xvoid Xfreespathinfo(spi) Xstruct SpathInfo *spi; X/* This routine frees all of the resoureces tied up in a SpathInfo X structure */ X{ X struct SpathNode *spn; X struct SregList *srl,*next; X X while (spn = (struct SpathNode *)RemTail((struct List *)spi)) X freespathnode(spn); X X for (srl = spi->spi_SregList; srl; srl = next) { X freesregexp(srl->srl_sreg); X next = srl->srl_next; X FreeMem(srl,sizeof(struct SregList)); X } X X FreeMem(spi,sizeof(struct SpathInfo)); X} X Xvoid Xfreespathnode(spn) Xstruct SpathNode *spn; X/* This routine frees the memory and lock in a SpathNode structure. */ X{ X if (spn->spn_NodeName) { X FreeMem(spn->spn_NodeName,strlen(spn->spn_NodeName)+1); X } X UnLock(spn->spn_Lock); X FreeMem(spn,sizeof(struct SpathNode)); X} X X X#ifdef __DEBUG__ X X/* This is some debugging stuff, not compiled into the release version. */ X Xvoid Xputs(c) Xchar *c; X{ X Write(Output(),c,strlen(c)); X Write(Output(),"\n",1); X} X X#include <stdarg.h> X Xextern void vsprintf(char *, char *, va_list); X Xvoid printf(f, ...) Xchar *f; X{ X char buff[100]; X va_list va; X X va_start(va,f); X vsprintf(buff,f,va); X va_end(va); X Write(Output(),buff,strlen(buff)); X} X X#endif END_OF_FILE if test 12546 -ne `wc -c <'spath.c'`; then echo shar: \"'spath.c'\" unpacked with wrong size! fi # end of 'spath.c' fi if test -f 'sreg_version.c' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'sreg_version.c'\" else echo shar: Extracting \"'sreg_version.c'\" $68 characters$ sed "s/^X//" >'sreg_version.c' <<'END_OF_FILE' X X Xconst __far char idString[] = "sreglib 9.4 ("__DATE__")\x0d\x0a"; END_OF_FILE if test 68 -ne `wc -c <'sreg_version.c'`; then echo shar: \"'sreg_version.c'\" unpacked with wrong size! fi # end of 'sreg_version.c' fi if test -f 'sreg_version.i' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'sreg_version.i'\" else echo shar: Extracting \"'sreg_version.i'\" $44 characters$ sed "s/^X//" >'sreg_version.i' <<'END_OF_FILE' X XVERSION equ 9 XREVISION equ 4 X X X X X END_OF_FILE if test 44 -ne `wc -c <'sreg_version.i'`; then echo shar: \"'sreg_version.i'\" unpacked with wrong size! fi # end of 'sreg_version.i' fi if test -f 'sregexp.fd' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'sregexp.fd'\" else echo shar: Extracting \"'sregexp.fd'\" $279 characters$ sed "s/^X//" >'sregexp.fd' <<'END_OF_FILE' X##base _SregExpBase X##bias 30 X##public XParseSregExp(p)(a0) XFreeSregExp(p)(a0) XMatchSregExp(p,p1,n)(a0,a1,d0) XMatchNSregExp(p,p1,n)(a0,a1,d0,d1) XIsWild(p)(a0) XAnchorPath(anchor,path)(a0,a1) XNextFile(p1,p2,n,n1)(a0,a1,d0,d1) XBuildPath(p1,p2,n)(a0,a1,d0) XFreeSpathInfo(p)(a0) X##end END_OF_FILE if test 279 -ne `wc -c <'sregexp.fd'`; then echo shar: \"'sregexp.fd'\" unpacked with wrong size! fi # end of 'sregexp.fd' fi if test -f 'sregexp.h' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'sregexp.h'\" else echo shar: Extracting \"'sregexp.h'\" $1868 characters$ sed "s/^X//" >'sregexp.h' <<'END_OF_FILE' X X/* This is used for COMPILING sregexp.library, it should not be included X if you just USE the library. See sregexpbase.h */ X X#include <stddef.h> X#include <stdlib.h> X#include <string.h> X#include <ctype.h> X#include <clib/exec_protos.h> X#include <clib/dos_protos.h> X#include <libraries/dosextens.h> X#include "sregexpbase.h" X X#define TRUE 1 X#define FALSE 0 X X X#define MEM_ERROR ERROR_NO_FREE_STORE /* report no mem */ X#define ILLEGAL_ERR ERROR_INVALID_COMPONENT_NAME /* bad sregexp */ X X X/* some handy fingersaving macros. */ X#define realen(a) (((a)->sre_Flag&(SRF_REPEAT|SRF_NOT))?0:(a)->sre_MinLen) X#define isfixed(s) (((s)->sre_Flag&(SRF_REPEAT|SRF_NOT|SRF_FIXLEN))==SRF_FIXLEN) X#define matchset(s,c) ((s)->sre_Data.setchar[(c)/8] & 1 << (c)%8) X#define getmem(a) AllocMem(a,0) X Xstatic struct SregExp * parsesub(char **, char); Xstatic struct SregExp * makesum(struct SregList *, int); Xstatic struct SregExp * makeor(struct SregList *,int); Xstatic struct SregExp * parseone(char **, char); Xstatic char onechar(char **, char); Xstatic char * makeset(char **); Xstatic int matchsum(struct SregExp *[], int, char *, int, int); Xstatic void report(int); Xstatic struct SpathNode * makespathnode(BPTR, char *, struct SregList *); Xstatic void freespathnode(struct SpathNode *); Xstatic struct SregList * parsepath(char *); X Xextern struct SregExp * parsesregexp(char *); Xextern void freesregexp(struct SregExp *); Xextern int matchsregexp(char *, struct SregExp *, int); Xextern int matchnsregexp(char *, struct SregExp *, int, int); Xextern int iswild(char *); Xextern struct SpathInfo * anchorpath(char *, char *); Xextern int nextfile(struct SpathInfo *, char *, int, int); Xextern int buildpath(struct SpathInfo *, char *, int); Xextern void freespathinfo(struct SpathInfo *); X END_OF_FILE if test 1868 -ne `wc -c <'sregexp.h'`; then echo shar: \"'sregexp.h'\" unpacked with wrong size! fi # end of 'sregexp.h' fi if test -f 'sregexp.uu' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'sregexp.uu'\" else echo shar: Extracting \"'sregexp.uu'\" $12272 characters$ sed "s/^X//" >'sregexp.uu' <<'END_OF_FILE' Xbegin 600 sregexp.library XM```#\P`````````!``````````````AC```#Z0``"&-P_TYU2OP````$```!V XM6H`)"0````%*```0P````!X````N````+@```&8```"2````R@```-@```#L' XM```!.@```5P```%H```!=````8````&,```!F````:0```&P```!O/_____@, XM```("0#````*```!2N````X&`-```!0`"=```!8`!,```!@``!#``````"\,4 XM*$`I3@`B*4@`*D/Z`)YP`$ZN_=@I0``F9A9(YP$&+CP``X`'+'@`!$ZN_Y1,P XMWV"`(`PH7TYU4FX`(`BN``,`#B`.3G5P`%-N`"!F"@@N``,`#F<"81).=4INL XM`"!G"@CN``,`#G``3G5(YR`$*DXL;0`B)"T`*B)-(%$B:0`$(H@A20`$(FT`B XM)DZN_F)P`")-,"T`$)/`T&T`$DZN_RX@`DS?(`1.=7``3G5D;W,N;&EB<F%RP XM>0!S<F5G97AP+FQI8G)A<GD`3G$O#"A.3KH`<BA?3G4O#"A.3KH(MBA?3G4O^ XM#"A.3KH)'BA?3G4O#"A.3KH)."A?3G4O#"A.3KH.Y"A?3G4O#"A.3KH//BA?! XM3G4O#"A.3KH5*"A?3G4O#"A.3KH8CBA?3G4O#"A.3KH98"A?3G4C?B@I6UT_1 XM)7PG*@!.5?_\*TC__'``0>W__$ZZ``HB0"`)3EU.=4CG.#(D`$Y5_^PK2/_\; XM<``K0/_TE<IV`'@`(&W__"!0M!!F``$F0?H.IBM(_^QP`4'M_^Q.N@/6(D`@> XM"6```=Y@``$(<`$@;?_\3KH#P"9`(`MF!&```6)*K?_T9RH@;?_X+$AR`'`(0 XM3KH>U"U```0K;@`$__A*K?_X9BYP9TZZ#C)@``$T8")R`'`(3KH>L"M`__0K` XM;?_T__A*K?_X9@IP9TZZ#@Y@``$0+&W_^"R++&W_^'``+4``!%*#+&W__"Q6$ XM#!8`?&8``((@`R!M__1.N@%2)D`@"V8$8```W"`*9RH@;?_P+$AR`'`(3KH>V XM4"U```0K;@`$__!*K?_P9BIP9TZZ#:Y@``"P8!YR`'`(3KH>+"1`*TK_\$JMF XM__!F"G!G3KH-CF```)`L;?_P+(LL;?_P<``M0``$4H0L;?_\4I9P`"M`__1V' XM`"QM__PL5K069@#^\"`#(&W_]$ZZ`,8F0"`+9@)@4"`*9T@@;?_P+$AR`'`(! XM3KH=QBU```0K;@`$__!*K?_P9@AP9TZZ#21@)BQM__`LBRQM__!P`"U```12, XMA"`$($I.N@%.)D`@"V8"8`0@"V!D*VW_]/_X8"0@;?_X*V@`!/_T(FW_^"!1` XM3KH&9'`((&W_^$ZZ'7(K;?_T__A*K?_X9M8K2O_X8"0@;?_X*V@`!/_T(FW_] XM^"!13KH&-'`((&W_^$ZZ'4(K;?_T__A*K?_X9M9P`$Y=3-],'$YU2.<^,B1(V XM)`!X`'H$2H)F$B`\````TDZZ#'9P`&```+!@%G`!L()F$"Q2<`@@2DZZ'/H@# XM#F```)A"IR("Y8$@`5"`(A].NAS4+$`@#F8,<&=.N@P\<`!@``!V'+P`!QU\4 XM`````2U"``1V`&!4(%(2*``!2(%(P7P#PH9G!'``8`H@4C(H``)(P2`!V(`@9 XM4A(H``%(@4C!?`?"AGP$O(%F!'`$8`)P`,H`(`/E@"V2"`@F:@`$<`@@2DZZV XM''`D2U*#M(-NJ#U$``*++@`!(`Y,WTQ\3G5(YSXR)$@D`'H$0J<B`N6!(`%0/ XM@"(?3KH<+BQ`(`YF#'!G3KH+EG``8```Y!R\``8=?`````$M0@`$=@!@``#`4 XM2H-F(B!2$"@``4B`2,!R`\"!9P9X`&```'(@4C`H``)(P"@`8&0@4A(H``%(R XM@4C!?`/"AF<$<`!@"B!2,B@``DC!(`&PA&=">@`@4A(H``%(@4C!?`/"AF<$6 XM<`!@"B!2,B@``DC!(`&PA&P>(%(0*``!2(!(P'(#P(%G!'@`8`H@4C`H``)(B XMP"@`(%(2*``!2(%(P7P'PH9\!+R!9@1P!&`"<`#*`"`#Y8`MD@@()FH`!'`(, XM($I.NAM>)$M2@[2#;@#_/CU$``*++@`!(`Y,WTQ\3G5(YS`R)$@D`$Y5__P@1 XM4A`0D#P`*F<``3YJ))`\`-9G``&4D#P`(V<\50!G``%85P!G``"04P!G``%\F XM8``!B)`\`!5G``#@D#P`'&<``(A5`&<``6*0/``?9P`!6E4`9T)@``%B4I)P) XM`"!*3KK_E"9`(`MF!G``8``"$@@K`````6<6(#P```#23KH*'"!+3KH#FG``S XM8``!]`CK``$``6```>A2DG``($I.NO]6)D`@"V8&<`!@``'4".L````!8``!E XMR%*2<"D@2DZZ^RHF0%*28``!ME*2<@!P"$ZZ&E8F0"(+9@QP9TZZ";YP`&``^ XM`9P6O``!%WP`!``!-WP``0`"($I.N@'8)T``!$JK``1F#G`$($M.NAHL<`!@> XM``%N4I)@``%F4I)R`'`(3KH:!B9`(@MF#'!G3KH);G``8``!3!:\``(7?``$S XM``$W?``!``)@``$V4I)R`'`(3KH9UB9`(@MF#'!G3KH)/G``8``!'!:\``(76 XM?``&``$W?``!``)@``$&4I)R`'`(3KH9IB9`(@MF#'!G3KH)#G``8```[!:\^ XM``47?``$``$W?`````)@``#6(#P```#23KH(ZG``8```R'(`<`A.NAEH)D`B# XM"V8,<&=.N@C0<`!@``"N%WP`!``!2@)F&G``($I.N@"D%T``!!:\``,W?``!` XM``)@``"(*U+__'8`8`)2@W``0>W__$ZZ`'X2`$H!9NXW0P`"<@&R@V82<``@+ XM2DZZ`&870``$%KP``V!0%KP`!'(`<`'0@TZZ&.XG0``$*VL`!/_\2JW__&82< XM<&=.N@A,<`0@2TZZ&.!P`&`B(&W__%*M__PL2'``($I.N@`:'(!*%F;H+&W_8 XM_!R\```@"TY=3-],#$YU2.<@("1()``@4@P0`"=F!%*28"8@4A`02(!(P$'Z5 XM^1Y.NA1F(D`@"68,2@)G#")2#!$`+68$<`!@"B!24I(0$$B`2,!,WP0$3G5(; XMYS\P)$A.5?_\&WP``/__=``@4@P0`'YF"%*2&WP``?__<@!P($ZZ&"XF0"(+` XM9@QP9TZZ!Y9P`&```0QV`&`,$`-(@!>\`````%(#MCP`(&WN8```DG0!(%(," XM$``M9EI2DG`!($I.NO].&`!*!&9$(#P```#23KH'4G`@($M.NA?F<`!@``#`` XM8"H0`TB`2,!R"$ZZ$IXJ`!(#2(%(P2`!<@A.NA).(@!\`>.F(@:#,U@`4@.X> XM`VS28"P2`TB!2,$@`7((3KH2;"(`*@$<`TB&2,8@!G((3KH2&BP`?@'MIRP'C XMC3-8`$AX``$@2B`?3KK^QA8`2@-F`/]>2@)G""!2#!``76<:2'@`TB`?3KH&Z XMO$AX`"`@2R`?3KH73'``8"9*+?__9QYV`&`4'`-(AAH#2(4:,U``1@47A6``& XM4@.V/``@;>8@"TY=3-\,_$YU2.<P("1(=``,$@`'9P8,$@`&9B(@*@`$Y8`DZ XM`'8`8`X@`^6`('(("$ZZ_]92@[:J``1M[&`N#!(`!&88(&H`!$ZZ$E8F`%*#D XM(`,@:@`$3KH6R&`0#!(``68*<"`@:@`$3KH6MG`(T((@2DZZ%JQ,WP0,3G5(, XMYS`P)$@F220`($I.NA(6(@`@`B)+($I.N@`,)@`@`TS?#`Q.=4CG/C(D2"9)8 XM)``F`0@K``$``6<``.Y*@V<&#!,``F8&>`%@``+>,"L``DC`L(-N*A`K``%() XM@$C`"````F<B2FL``F<6,"L``DC`(@/!04ZZ$+HB`"`!2H!G!G@`8``"I'P!B XMS"L``0(K`/P``0@K``(``6<P+$I@(C(K``)(P2`"(DL@3DZZ_WHH`$J$9@1@- XM``)R,BL``DC!W<$B#I**MH%NUF!2*@-@."(%(`(B2R!*3KK_3B@`2H1G)`CKA XM``$``2(#DH4@`B)+($K1Q4ZZ_S(H`$J$9P)@'@BK``$``5.%2FL``F<*,"L`S XM`DC`(@!@`G(!LH5OLG`"@`:!*P`!8``"`CPK``)(QKR#;A@<*P`!2(9(Q@@&0 XM``)G$#PK``)(QKR#9P9X`&```=H<$U,&9P``?E,&9P`!7%,&9S93!F<``5Y3! XM!F<``8Q3!F<``9!3!F<$8``!KB\"+P,O"B\K``1(:P`(3KH!N$_O`!0H`&``N XM`9)\`;R#9BI*@F<*'!*\*P`$9R1@'!P22(9!^A)3T,8<*P`$2(9#^A)'TL8<1 XM$+P19P9X`&```5QX`6```59\`;R#9C0<$DB&2,8@!G((3KH/BBP`(&L`!-'&B XM'!!(ADC&$!)(@$C`<@A.N@\P<@'AH2`!P(9F``"F2H)G!&```)@0$DB`0?H0' XMY=#`<``0$`@```=G0A`22(!!^A+9T,!P`!`0<@A.N@]@(&L`!-'`$!!(@$C`N XM+``0$DB`0?H2M]#`<``0$'((3KH/"G(!X:$@`<"&9DA@0!`22(!!^A&3T,!P( XM`!`0<@A.N@\>(&L`!-'`$!!(@$C`+``0$DB`0?H1<=#`<``0$'((3KH.R'(!= XMX:$@`<"&9@9X`&```'AX`6```')X`'`!L(-7Q$0$8&1*@F<8(`,B:P`$($I.J XMN@]B(@!X`$J!5\1$!&!((`,B:P`$($I.N@^R(@!X`$J!5\1$!&`P>`!*@U?$Z XM1`1@)GH`8!PB`R`"+`7EAB)S:`@@2DZZ_1`H`$J$9P)@"%*%NJL`!&W>""L`P XM```!9PQP`$J$5\!$`&`$8`(@!$S?3'Q.=4CG/S(D;P`H)F\`,"0O`#0F+P`XA XM3E4``&`X(%(R*``"2,$@`R)2($M.NORX*@!*A68&<`!@``)<(E(R*0`"2,'74 XMP2)2,BD``DC!E(%8BE.M`#!*K0`P9P``>B)2$BD``4B!2,%P!\*`<`2P@6>L] XM8&(@+0`P4X#E@")R"``R*0`"2,$@`RXM`#!3A^6'(G)X`"XM`#!3A^6'+')X@ XM`#XN``)(QT2'0?,H`-''3KK\-BH`2H5F!G``8``!VB(M`#!3@>6!(G(8`#(I& XM``)(P92!4ZT`,$JM`#!G("(M`#!3@>6!(G(8`!(I``%(@4C!<`?"@'`$L(%GV XM`/]Z2JT`,&8&<`%@``&0?`!X`6```10B!.6!(G(8`!(I``%(@4C!<`?"@'`$+ XML(%F``#*8```IB`$Y8`B<@@`,BD``DC!(`,N!.6'(G)X`"!+T<9.NON8*@!*0 XMA6<``'PO`R\&+PLO!"\*3KK^H$_O`!0J`$J%9@9P`&```2(O`R`"D(8B!.6![ XM(G(8`#(I``)(P42!TH`O`2($Y8$B<A@`,BD``D'S:`#0P4A0("T`,)"$4X`O& XM`'`!T(3E@$AR"`!.NOY*3^\`%"H`2H5F!G``8```S'`!8```QE*&(`*0AB($< XMY8$@<A@`,B@``DC!LH!O`/]&<`!@``"F8"PB!.6!('(8`!(H``%(@4C!?@/"C XMAV<$<`!@$"($Y8$@<A@`,B@``DC!(`'<@%*$("T`,%.`L(1N`/[D<`&PK0`P2 XM9A(B`B`#(E(@2TZZ^J8N`"`'8$XL`F`$@8@`R)2($M.NOJ0+@!*AV<H+P,@O XM`I"&+P!(<V@`("T`,%.`+P!(:@`$3KK]C$_O`!1*@&<$<`%@$%.&(E(P*0`"` XM2,"PAF^X<`!.74S?3/Q.=4Y5__PK2/_\<`!![?_\3KKX!A(`2@%F\"!M__QR. XM`$H05L%$`2`!3EU.=4CG("`D`)'(3KH0PB1`(`IG!"5"`)1,WP0$3G4E`$YQ9 XM<W)E9VQI8B`Y+C0@*$UA>2`Q,"`Q.3DQ*0T*`$CG.#).5?_D*TC__"M)__ARQ XM`'`03KH0.BM`__1*K?_T9@QP9TZZ_YYP`&```Z0@;?_T3KH*I"MM__C_[&`$3 XM4JW_["!M_^P,$``Z9Q(@;?_L#!``+V<((&W_[$H09N`@;?_L#!``.F8``OIR= XM`"@M_^R8K?_X<`'0A$ZZ#]8K0/_H2JW_Z&8@<&=.NO\Z<!`@;?_T3KH/S'`0? XM(&W_]$ZZ#$P`&```RPK;?_X_^PK;?_H_^1@$B!M_^12K?_D(FW_[%*M_^P0L XMD2!M_^P,$``Z9N0@;?_D$+P``"!M_^A.NO`:)D`@;?_H3KH*^%*`(&W_Z$ZZ= XM#VX@"V80<!`@;?_T3KH/8'``8``"RB!M_^Q**``!9S0@;?_T+$AP`2!`T>W_Y XM[$ZZ`K8M0``,2JX`#&8B($M.NO@6<!`@;?_T3KH/)'``8``"CF`*(&W_]'``G XM(4``#`P3``5F``#*</X@;?_\3KH.:"0`2H)F%"!+3KKWW"!M__1.N@C2<`!@7 XM``)6<@!P`DZZ#LXK0/_H2JW_Z&8@<&=.NOXR(`).N@Y(($M.NO>J(&W_]$ZZ! XM"*!P`&```B0@;?_H$+P`.B!M_^@1?`````$@;?_T(F@`#"!M_^@@`DZZ`X0K` XM0/_P2JW_\&8D(`).N@X`<`(@;?_H3KH.=B!+3KKW6"!M__1.N@A.<`!@``'2, XM(&W_\"%M_^@!%")M__`@;?_T3KH.7"`"3KH-QF```3PB;``F(FD`(B`I`!CEW XM@")`("D`!.6`)$!@``$:("H`*.6`*T#_Y")M_^02$4B!2,%P`")+>`$@1-'MW XM_^1.NO>$*`!*A&<``.AR`")M_^08$4B$2,1P`M"$3KH-UBM`_^A*K?_H9AIPA XM9TZZ_3H@2TZZ]K@@;?_T3KH'KG``8``!,B!M_^12K?_D%A`K;?_H_^Q@%"!MJ XM_^Q2K?_L(FW_Y%*M_^00D5,#2@-NZ"!M_^Q2K?_L$+P`.B!M_^P0O```2JH`C XM!&88</X@;?_H3KH,W"0`2H)F`F!8(`).N@SF(&W_]")H``P@;?_H<`!.N@)(, XM*T#_\$JM__!F("!M_^A.N@C"4H`@;?_H3KH-."!M__1.N@<6<`!@``":(&W_Z XM\"%M_^@!%")M__`@;?_T3KH-)"`2Y8`D0"`*9@#^Y"!+3KKUZF!J(&W_^$H08 XM9R@@;?_T+$@@;?_X3KH`8BU```Q*K@`,9AIP$"!M__1.N@S6<`!@0&`*(&W_> XM]'``(4``#"!M__0B:``,(&W__'``3KH!J"M`__!*K?_P9@@@;?_T3KH&B")MC XM__`@;?_T3KH,IB`M__1.74S?3!Q.=4CG,#!.5?_L*TC__'0!E\M"IR!M__Q.+ XMN@?P4H`B'TZZ#%@K0/_P2JW_\&8,<&=.NON\<`!@``$^(FW__"!M__!.N@@&C XM*VW_\/_X8```N'`$0_H&J"!M__A.N@>^(@!*@68(=H!8K?_X8`)V`"MM__C_Y XM]&`$4JW_^")M__A*$6<*(FW_^`P1`"]FZB)M__@4$2)M__@2O```(&W_]$ZZ) XM[((K0/_L2JW_[&8$8```BB!M_^R'*``!(&W_^%*M__@0@B(+9AIR`'`(3KH+8 XMKB9`)$LB"F8F<&=.NOL48%I@''(`<`A.N@N4)4``!"1J``0B"F8(<&=.NOKV4 XM8#QP`"5```0DK?_L(&W_^$H09P9*`F8`_SZT/``O9@@@4@CH``8``2!M__!.K XMN@;B4H`@;?_P3KH+6"`+8#Y*K?_L9P@@;?_L3KKT+B!M__!.N@:^4H`@;?_PM XM3KH+-&`62I)G!B!23KKT$'`(($I.N@L@)&H`!"`*9N9P`$Y=3-\,#$YU2.<PA XM,B0`)$@F27(`(#P```$:3KH*Z"Q`(@YF#'!G3KKZ4'``8```=DJ"9P@@`DZZV XM"IPF`'#^($I.N@HZ+4`!#$JN`0QF$"`\```!&B!.3KH*O'``8$8M2P$00>X`F XM""`N`0Q.N@HX(@!*@688("X!#$ZZ"AH@/````1H@3DZZ"HYP`&`8/7P```$8> XM<``M0`$42H)G!B`#3KH*-"`.3-],#$YU2.<\,B1()DDD`"8!3E7__'(`<`!.9 XMN@J4*`#(O```\`!G!G#\8``#1"QJ``A*K@`$9A`@/````.A.NOF4</]@``,J9 XM2JX!$&8P""X``0$99P1@``,(".X``0$92H-M``+\(`(B2R!*3KH#"B(`(`%@` XM``+Z8`1@``+D""X```$99P1@``*&(FX!$")1#!$`!698,BX!&$C!"`$``68`O XM`KX@+@$,3KH)IB(`2H%F!&```JP([@`!`1D([@`"`1D@;@$0(F@`!$'Z!!0@Z XM+@$,3KK^D"Q`(`YF!G#^8``"D").($I.N@F88`#_*B)N`1`B40P1``1G#B)N] XM`1`B40P1``-F``(T(FX!$")1$"D``4B`2,`(```'9@`"'@@N``$!&6<$8``"1 XM.`CN``$!&2`N`0Q.N@CZ*``B;@$0(E$,$0`$9A1P_B)N`1`B42!I``1.N@B$H XM*@!@'B!N`1`@4!MH``3__AM\``#__W#^0>W__DZZ"&0J`"`$3KH(M$J%9@1@( XM``'<0>X`""`%3KH(<B(`2H%F#"`%3KH(5G#^8``!T"`%3KH(2B!N`1!*J``$8 XM9D)*K@`,;PA*@VT``:1@'"!N`1`@4!`H``%(@$C`"```!F8``8Q*@VX``88@Y XM`B)+($I.N@&4(@`@`6```81@!&```6Y*K@`,;P`!9B!N`1`B:``$0>X`$"`NE XM`0Q.NOU6+$`@#F8&</Y@``%6(DX@2DZZ"%Y@`/WP8``!-F```0QR`'``3KH(> XM>BH`RKP``/``9P9P_&```2IP`"!N`1`B4$'N`!!.NO%V*@!*A6<``)9*K@`,G XM;QHB;@$0(E$:*0`!2(5(Q0@%``=G!@CN```!&2)N`1!*J0`$9CA*K@`,;P9*% XM@VU@8!@B;@$0(E$:*0`!2(5(Q0@%``9F2DJ#;D8@`B)+($I.N@#"*@`@!6``P XM`+)@,DJN``QO+"!N`1`B:``$0>X`$"`N`0Q.NOR*+$`@#F8&</Y@``"*(DX@F XM2DZZ!Y)@`/TD2JX`#&]`(FX!$")1$"D``4B`2,`(```'9RP(K@```1DB;@$00 XM0>X`$"`N`0Q.NOQ"+$`@#F8$</Y@0B).($I.N@=,8`#\WD'N``@@+@$,3KH&# XMU"(`2H%F`/[D3KH&\"(`LKP```#H9P1P_F`0($I.N@<L($Y.N@%"8`#\J$Y=5 XM3-],/$YU2.<@,B10<@!T`;2`;P9P_6```,9*DF<82JH!%&<28`(D4BQ22I9G( XM""Q22JX!%&;P)FH!%"0+9P``E&`,)`%2@2Q+4HL3EB@`2A-G!+"!;NRP@6X`S XM`'AP_6```'Y@``!N""H``@$99Q0D`5*!$[P`+R@`L(%N5'#]8%Y@3D?J`!!@E XM#"0!4H$L2U*+$Y8H`$H39P2P@6[LL(%N!'#]8#HL4DJ69A0L:@$0+%84+@`!J XM2()(P@@"``9G$B0!4H$3O``O*`"P@6X$</U@#B122I)FD!.\```8`"`!3-],` XM!$YU2.<`,DY5__PK2/_\8`8@2DZZ`$0@;?_\3KH&("1`(`IF["!M__PF:``,( XM8!0@4TZZ[M(L:P`$<`@@2TZZ!=XF3B`+9NAP$"!M__Q.N@7.3EU,WTP`3G4O\ XM"B1(2JH!%&<2(&H!%$ZZ`312@"!J`11.N@6J("H!#$ZZ!2(@/````1H@2DZZK XM!98D7TYU+P`N+BXO``!#Z``$((EP`"%```0A2``(3G5.<4J!:PQ*@&L880``9 XM8B`!3G5$@4J`:Q9A``!41($@`4YU1(!A``!(1($@`4YU1(!A```\(`%.=4YQ. XM80``,B`!3G5*@6L(2H!K$F```")$@4J`:Q)A```81(!.=42`80``#D2`3G5$( XM@&````1.<4J!9QY(04I!9D(O`DA!)`"$P6D4(@)"04A!<``P`B0?3G4B`'#_X XM3G4O`R0`0D)(0H3!-@)(0T)#-`"$P38"(`-"0DA"(@(F'R0?3G5(YS@`)`!"2 XM0DA"A,$V`G0`-`/&P4A!.`+(P4A#UH20@VL*(@`@`DS?`!Q.=5."T(%K^B(`O XM(`),WP`<3G4B2&`"4HA*$&;Z(`B0B4YU2H!F&'``8"1@$DH!9P93@$J`9@1PM XM`&`44HA2B1(0LA%GZ+(19`1P_V`"<`%.=4YQ+PHD2&`$4HE2B!"12A!F]B`*+ XM)%].=4YQ8`P2`+(09@0@"&`04HA*$&;P2H!F!"`(8`)P`$YU3G%(YR`P2H!FP XM&'``8%!@$DH!9P93@$J`9@1P`&!`4HA2B1(0=``4`47Z`D74PG0`%!%'^@([, XMUL(4$K039])T`!0!1_H"*];"=``4$47Z`B'4PA03M!)D!'#_8`)P`4S?#`1.^ XM=4YQ``0$!`0$!`0$!$1$1$1$!`0$!`0$!`0$!`0$!`0$!`0$0!`0$!`0$!`0T XM$!`0$!`0$!D9&1D9&1D9&1D0$!`0$!`0DY.3DY.3DY.3DY.3DY.3DY.3DY.3I XMDY.3DY,0$!`0$!`S,S,S,S,S,S,S,S,S,S,S,S,S,S,S,S,S,Q`0$!`$````Q XM````````````````````````````````````````````````````````````` XM````````````````````````````````````````````````````````````` XM``````````````````````````````````````````````````````$"`P0%/ XM!@<("0H+#`T.#Q`1$A,4%187&!D:&QP='A\@(2(C)"4F)R@I*BLL+2XO,#$RL XM,S0U-C<X.3H[/#T^/T!!0D-$149'2$E*2TQ-3D]045)35%565UA96EM<75Y?5 XM8$%"0T1%1D=(24I+3$U.3U!14E-455976%E:>WQ]?G^`@8*#A(6&AXB)BHN,^ XMC8Z/D)&2DY25EI>8F9J;G)V>GZ"AHJ.DI::GJ*FJJZRMKJ^PL;*SM+6VM[BYG XMNKN\O;Z_P,'"P\3%QL?(R<K+S,[.S]#1TM/4U=;7V-G:V]S=WM_@X>+CY.7F1 XMY^CIZNOL[>[O\/'R\_3U]O?X^?K[_/W^_P```````0(#!`4&!P@)"@L,#0X/S XM$!$2$Q05%A<8&1H;'!T>'R`A(B,D)28G*"DJ*RPM+B\P,3(S-#4V-S@Y.CL\N XM/3X_0&%B8V1E9F=H:6IK;&UN;W!Q<G-T=79W>'EZ6UQ=7E]@86)C9&5F9VAI7 XM:FML;6YO<'%R<W1U=G=X>7I[?'U^?X"!@H.$A8:'B(F*BXR-CH^0D9*3E)66` XMEYB9FIN<G9Z?H*&BHZ2EIJ>HJ:JKK*VNK["QLK.TM;:WN+FZN[R]OK_`P<+#I XMQ,7&Q\C)RLO,SL[/T-'2T]35UM?8V=K;W-W>W^#AXN/DY>;GZ.GJZ^SM[N_P3 XM\?+S]/7V]_CY^OO\_?[_````2.<@`B(()``L;``F3J[_K$S?0`1.=4YQ+PXB< XM`"QL`"9.KO^F+%].=4CG(`(B`"0(+&P`)DZN_YI,WT`$3G5.<4CG(`(B`"0(O XM+&P`)DZN_Y1,WT`$3G5.<2\.(@`L;``F3J[_@BQ?3G4O#BQL`"9.KO]\+%].Q XM=4YQ+PXB`"QL`"9.KO\N+%].=2\.+&P`(DZN_SHL7TYU3G$O#B)(+&P`(DZN> XM_RXL7TYU+PXL;``B3J[_"BQ?3G5.<2\.+&P`(DZN_O@L7TYU3G$O#B)(+&P`Y XM(DZN_MHL7TYU+PXL;``B3J[^SBQ?3G5.<0```^P````7``````````8````*F XM````$@```!H````B````)@```"H````N````,@```#8````Z````<````!8`T XM``"*````/@```$(```!&````2@```$X```!2````5@```%H```!>````````( X"`_**_ X`` Xend Xsize 8732 END_OF_FILE if test 12272 -ne `wc -c <'sregexp.uu'`; then echo shar: \"'sregexp.uu'\" unpacked with wrong size! fi # end of 'sregexp.uu' fi if test -f 'sregexp_protos.h' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'sregexp_protos.h'\" else echo shar: Extracting \"'sregexp_protos.h'\" $607 characters$ sed "s/^X//" >'sregexp_protos.h' <<'END_OF_FILE' X X#ifndef LIBRARIES_SREGEXPBASE_H X#include <libraries/sregexpbase.h> X#endif X Xextern struct SregExpBase *SregExpBase; X Xextern struct SregExp * ParseSregExp(char *); Xextern void FreeSregExp(struct SregExp *); Xextern int MatchSregExp(char *, struct SregExp *, int); Xextern int MatchNSregExp(char *, struct SregExp *, int, int); Xextern int IsWild(char *); Xextern struct SpathInfo * AnchorPath(char *, char *); Xextern int NextFile(struct SpathInfo *, char *, int, int); Xextern int BuildPath(struct Spathinf *, char *, int); Xextern void FreeSpathInfo(struct SpathInfo *); X END_OF_FILE if test 607 -ne `wc -c <'sregexp_protos.h'`; then echo shar: \"'sregexp_protos.h'\" unpacked with wrong size! fi # end of 'sregexp_protos.h' fi if test -f 'sregexpbase.h' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'sregexpbase.h'\" else echo shar: Extracting \"'sregexpbase.h'\" $3432 characters$ sed "s/^X//" >'sregexpbase.h' <<'END_OF_FILE' X X/* X * X * sregexpbase.h -- C include file for sregexp.library X * X * Copyright (C) 1991, Jon Spencer. X * X * Created: April 20,1991 X * X */ X X#ifndef LIBRARIES_SREGEXPBASE_H X#define LIBRARIES_SREGEXPBASE_H X X#ifndef EXEC_TYPE_H X#include <exec/types.h> X#endif X X#ifndef EXEC_LISTS_H X#include <exec/lists.h> X#endif X X#ifndef EXEC_LIBRARIES_H X#include <exec/libraries.h> X#endif X X#ifndef LIBRARIES_DOS_H X#include <libraries/dos.h> X#endif X X X/* X * X * Library base structure, all of these fields are private, and X * should not be accessed. X * X */ X Xstruct SregExpBase { X struct Library LibNode; X struct Library *SysBase; X struct Library *DOSBase; X BPTR Segment; X}; X X#define SREGEXPNAME "sregexp.library" X X X/* X * X * Here are the defines for the structures used and returned by X * the various sreg functions. They should probably not be X * accessed for there contents, unless you have really good X * reason... X * X */ X Xstruct SregExp { X char sre_Type,sre_Flag; X SHORT sre_MinLen; X union { X char onechar; X char *setchar; X char *string; X LONG number; X } sre_Data; X struct SregExp * sre_List[]; X}; X X X/* This is an internal structure for a singly linked list of sregexp's */ Xstruct SregList { X struct SregExp *srl_sreg; X struct SregList *srl_next; X}; X X X/* various types of wildcard pattern elements. X Goes in struct SregExp.type field */ X X#define SRP_SETCHAR 1 X#define SRP_ANYCHAR 2 X#define SRP_ONECHAR 3 X#define SRP_STRING 4 X#define SRP_NULL 5 X#define SRP_OR 6 X#define SRP_SUM 7 X X X X/* various flags to mark special properties of patterns. X Goes in struct SregExp.flag */ X X#define SRF_NOT (1<<0) X#define SRF_REPEAT (1<<1) X#define SRF_FIXLEN (1<<2) X#define SRF_JUSTDIRS (1<<6) /* special flag used in path matching */ X#define SRF_RECURSE (1<<7) /* dito. */ X X/* defines for the wildcard characters */ X X#define CHR_REPEAT '#' X#define CHR_NOT '~' X#define CHR_OPENBRACE '(' X#define CHR_CLOSEBRACE ')' X#define CHR_OPENSET '[' X#define CHR_CLOSESET ']' X#define CHR_ANYCHAR '?' X#define CHR_NULL '%' X#define CHR_OR '|' X#define CHR_ESCAPE '\'' X#define CHR_RANGE '-' X#define CHR_STAR '*' X X X X X/* These are the structures used for the path matching routines. */ X Xstruct SpathInfo { X struct SpathNode * spi_Head; X struct SpathNode * spi_Tail; X struct SpathNode * spi_TailPred; X struct SregList * spi_SregList; X}; X X X/* Note: because of the fileinfoblock, this whole structure MUST X be longword aligned. */ X Xstruct SpathNode { X struct SpathNode * spn_Succ; X struct SpathNode * spn_Pred; X struct FileInfoBlock spn_FIB; X BPTR spn_Lock; X struct SregList * spn_SregList; X char * spn_NodeName; X short int spn_Flags; X}; X X/* flags used in spn_Flags, which is really library private */ X#define SPF_DECEND (1<<0) /* Should recursively search, when we get the chance. */ X#define SPF_DONEONCE (1<<1) /* Already done it, don't do again */ X#define SPF_NEXTPARENT (1<<2) /* Next one is lock on parentdir */ X X X/* These are the possible error returns sent by NextFile and BuildPath */ X X#define SPE_ALL_DONE -1 /* no more matching files */ X#define SPE_ERROR -2 /* some error occured, see IoErr() */ X#define SPE_BUFF_FULL -3 /* you didn't give me enough room! */ X#define SPE_SIGBREAK -4 /* A control signal came through. */ X X X/* Some defines for what kind of events we match to. */ X X#define SP_DIRS_ONLY 1 X#define SP_BOTH 0 X#define SP_FILES_ONLY -1 X X#endif END_OF_FILE if test 3432 -ne `wc -c <'sregexpbase.h'`; then echo shar: \"'sregexpbase.h'\" unpacked with wrong size! fi # end of 'sregexpbase.h' fi if test -f 'sregexpbase.i' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'sregexpbase.i'\" else echo shar: Extracting \"'sregexpbase.i'\" $3339 characters$ sed "s/^X//" >'sregexpbase.i' <<'END_OF_FILE' X IFND LIBRARIES_SREGEXPBASE_I XLIBRARIES_SREGEXPBASE_I set 1 X X********************************************************************* X* * X* sregbase.i -- asm include file for sreg.library * X* * X* Copyright (C) 1991, Jon Spencer. * X* * X* Created: April 20,1991 * X* * X********************************************************************* X X IFND EXEC_TYPES_I X INCLUDE "exec/types.i" X ENDC X X IFND EXEC_LISTS_I X INCLUDE "exec/lists.i" X ENDC X X IFND EXEC_LIBRARIES_I X INCLUDE "exec/libraries.i" X ENDC X X IFND LIBRARIES_DOS_I X INCLUDE "libraries/dos.i" X ENDC X X X X; X; X; Library base structure, all of these fields are private, and X; should not be accessed. X; X; X X STRUCTURE SregExpBase,LIB_SIZE X APTR sb_SysBase X APTR sb_DOSBase X ULONG sb_SegList X LABEL SregExpBase_SIZE X X X XSREGEXPNAME macro X dc.b "sregexp.library",0 X endm X X; X; X; Here are the equates for the structures used and returned by X; the various sreg functions. They should probably not be X; accessed for there contents, unless you have really good X; reason... X; X; X STRUCTURE SregExp,0 X BYTE sre_Type X BYTE sre_Flag X SHORT sre_MinLen X ULONG sre_Data X APTR sre_List X LABEL SregExp_SIZE X X X; sre_Data is a union, here are its elements. Xsre_onechar EQU sre_Data Xsre_setchar EQU sre_Data Xsre_string EQU sre_Data Xsre_number EQU sre_Data X X X; This is an internal structure for a singly linked list of sregexp's X X STRUCTURE SregList,0 X APTR srl_sreg X APTR srl_next X LABEL SregList_SIZE X X X; various types of wildcard pattern elements. Goes in spat_t.type X XSRP_SETCHAR EQU 1 XSRP_ANYCHAR EQU 2 XSRP_ONECHAR EQU 3 XSRP_STRING EQU 4 XSRP_NULL EQU 5 XSRP_OR EQU 6 XSRP_SUM EQU 7 X X; various flags to mark special properties of patterns. X; Goes in SregExp.sre_Flag X X BITDEF SR,NOT,0 X BITDEF SR,REPEAT,1 X BITDEF SR,FIXLEN,2 X BITDEF SR,JUSTDIRS,6 X BITDEF SR,RECURSE,7 X X; equates for the wildcard characters X XCHR_REPEAT EQU '#' XCHR_NOT EQU '~' XCHR_OPENBRACE EQU '(' XCHR_CLOSEBRACE EQU ')' XCHR_OPENSET EQU '[' XCHR_CLOSESET EQU ']' XCHR_ANYCHAR EQU '?' XCHR_NULL EQU '%' XCHR_OR EQU '|' XCHR_ESCAPE EQU "'" XCHR_RANGE EQU '-' XCHR_STAR EQU '*' X X X; X; These are the structures used for the path matching routines. X; X X STRUCTURE SpathInfo,0 X APTR spi_Head X APTR spi_Tail X APTR spi_TailPred X APTR spi_SregList; X LABEL SpathInfo_SIZE X X X; Note: because of the fileinfoblock, this whole structure MUST X; be longword aligned. X X STRUCTURE SpathNode,0 X APTR spn_Succ X APTR spn_Pred X STRUCT spn_FIB,fib_SIZEOF X BPTR spn_Lock X APTR spn_SregList X APTR spn_NodeName X SHORT spn_Flags X LABEL SpathNode_SIZE X X; flags used in spn_Flags, which is really library private. X X BITDEF SP,DECEND,0 X BITDEF SP,DONEONCE,1 X BITDEF SP,NEXTPARENT,2 X X; These are the possible error returns sent by NextFile and BuildPath X XSPE_ALL_DONE EQU -1 XSPE_ERROR EQU -2 XSPE_BUFF_FULL EQU -3 XSPE_SIGBREAK EQU -4 X X X; Some defines for what kind of events we match to. X XSP_DIRS_ONLY EQU 1 XSP_BOTH EQU 0 XSP_FILES_ONLY EQU -1 X X ENDC END_OF_FILE if test 3339 -ne `wc -c <'sregexpbase.i'`; then echo shar: \"'sregexpbase.i'\" unpacked with wrong size! fi # end of 'sregexpbase.i' fi if test -f 'sregexps.uu' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'sregexps.uu'\" else echo shar: Extracting \"'sregexps.uu'\" $1705 characters$ sed "s/^X//" >'sregexps.uu' <<'END_OF_FILE' Xbegin 600 sregexps.lib XM```#YP````````/H`````````^D````%+PX@;P`(+&P``$ZN_^(L7TYU3G$`< XM``/OA@```U]3<F5G17AP0F%S90````$````(`0``!%]087)S95-R96=%>'``Y XM`````````````````_(```/G`````````^@````````#Z0````4O#B!O``@L[ XM;```3J[_W"Q?3G5.<0```^^&```#7U-R96=%>'!"87-E`````0````@!```#P XM7T9R9653<F5G17AP``````````````/R```#YP````````/H`````````^D`5 XM```&+PY,[P,```@@+P`0+&P``$ZN_]8L7TYU```#[X8```-?4W)E9T5X<$)A: XM<V4````!````#@$```1?36%T8VA3<F5G17AP``````````````````/R```#N XMYP````````/H`````````^D````'+PY,[P,```A,[P`#`!`L;```3J[_T"Q?$ XM3G5.<0```^^&```#7U-R96=%>'!"87-E`````0```!`!```$7TUA=&-H3E-R* XM96=%>'`````````````````#\@```^<````````#Z`````````/I````!2\.Q XM(&\`""QL``!.KO_*+%].=4YQ```#[X8```-?4W)E9T5X<$)A<V4````!````5 XM"`$```)?27-7:6QD```````````````#\@```^<````````#Z`````````/IL XM````!2\.3.\#```(+&P``$ZN_\0L7TYU```#[X8```-?4W)E9T5X<$)A<V4`` XM```!````"@$```-?06YC:&]R4&%T:````````````````_(```/G````````U XM`^@````````#Z0````<O#DSO`P``"$SO``,`$"QL``!.KO^^+%].=4YQ```#0 XM[X8```-?4W)E9T5X<$)A<V4````!````$`$```-?3F5X=$9I;&4`````````C XM`````````_(```/G`````````^@````````#Z0````8O#DSO`P``""`O`!`L* XM;```3J[_N"Q?3G4```/OA@```U]3<F5G17AP0F%S90````$````.`0```U]"T XM=6EL9%!A=&@````````````````#\@```^<````````#Z`````````/I````Q XM!2\.(&\`""QL``!.KO^R+%].=4YQ```#[X8```-?4W)E9T5X<$)A<V4````!_ XM````"`$```1?1G)E95-P871H26YF;P````````````````/R```#YP``````9 XM``/H`````````^D````````#[P(```5?3%9/1G)E95-P871H26YF;P```/__L XM_[("```$7TQ63T)U:6QD4&%T:````/___[@"```#7TQ63TYE>'1&:6QE____J XMO@(```1?3%9/06YC:&]R4&%T:```____Q`(```-?3%9/27-7:6QD``#____*E XM`@``!5],5D]-871C:$Y3<F5G17AP````____T`(```1?3%9/36%T8VA3<F5GQ XM17AP____U@(```1?3%9/1G)E95-R96=%>'``____W`(```1?3%9/4&%R<V533 X2<F5G17AP____X@````````/R_ X`` Xend Xsize 1188 END_OF_FILE if test 1705 -ne `wc -c <'sregexps.uu'`; then echo shar: \"'sregexps.uu'\" unpacked with wrong size! fi # end of 'sregexps.uu' fi if test -f 'sregexpsr.uu' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'sregexpsr.uu'\" else echo shar: Extracting \"'sregexpsr.uu'\" $1623 characters$ sed "s/^X//" >'sregexpsr.uu' <<'END_OF_FILE' Xbegin 600 sregexpsr.lib XM```#YP````````/H`````````^D````$+PXL;```3J[_XBQ?3G5.<0```^^&\ XM```#7U-R96=%>'!"87-E`````0````0!```$0%!A<G-E4W)E9T5X<```````> XM```````````#\@```^<````````#Z`````````/I````!"\.+&P``$ZN_]PL2 XM7TYU3G$```/OA@```U]3<F5G17AP0F%S90````$````$`0```T!&<F5E4W)EI XM9T5X<``````````````#\@```^<````````#Z`````````/I````!"\.+&P`C XM`$ZN_]8L7TYU3G$```/OA@```U]3<F5G17AP0F%S90````$````$`0``!$!-( XM871C:%-R96=%>'```````````````````_(```/G`````````^@````````#K XMZ0````0O#BQL``!.KO_0+%].=4YQ```#[X8```-?4W)E9T5X<$)A<V4````!N XM````!`$```1`36%T8VA.4W)E9T5X<`````````````````/R```#YP``````A XM``/H`````````^D````$+PXL;```3J[_RBQ?3G5.<0```^^&```#7U-R96=%R XM>'!"87-E`````0````0!```"0$ES5VEL9````````````````_(```/G````6 XM`````^@````````#Z0````0O#BQL``!.KO_$+%].=4YQ```#[X8```-?4W)E` XM9T5X<$)A<V4````!````!`$```-`06YC:&]R4&%T:````````````````_(`U XM``/G`````````^@````````#Z0````0O#BQL``!.KO^^+%].=4YQ```#[X8`8 XM``-?4W)E9T5X<$)A<V4````!````!`$```-`3F5X=$9I;&4`````````````# XM`````_(```/G`````````^@````````#Z0````0O#BQL``!.KO^X+%].=4YQ/ XM```#[X8```-?4W)E9T5X<$)A<V4````!````!`$```-`0G5I;&10871H````9 XM`````````````_(```/G`````````^@````````#Z0````0O#BQL``!.KO^R\ XM+%].=4YQ```#[X8```-?4W)E9T5X<$)A<V4````!````!`$```1`1G)E95-PO XM871H26YF;P````````````````/R```#YP````````/H`````````^D`````_ XM```#[P(```5?3%9/1G)E95-P871H26YF;P```/___[("```$7TQ63T)U:6QD, XM4&%T:````/___[@"```#7TQ63TYE>'1&:6QE____O@(```1?3%9/06YC:&]RB XM4&%T:```____Q`(```-?3%9/27-7:6QD``#____*`@``!5],5D]-871C:$Y3; XM<F5G17AP````____T`(```1?3%9/36%T8VA3<F5G17AP____U@(```1?3%9/B XM1G)E95-R96=%>'``____W`(```1?3%9/4&%R<V53<F5G17AP____X@``````' X#``/RU X`` Xend Xsize 1128 END_OF_FILE if test 1623 -ne `wc -c <'sregexpsr.uu'`; then echo shar: \"'sregexpsr.uu'\" unpacked with wrong size! fi # end of 'sregexpsr.uu' fi if test ! -d 'utils' ; then echo shar: Creating directory \"'utils'\" mkdir 'utils' fi if test -f 'utils/bumprev.c' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'utils/bumprev.c'\" else echo shar: Extracting \"'utils/bumprev.c'\" $1133 characters$ sed "s/^X//" >'utils/bumprev.c' <<'END_OF_FILE' X X#include <stdio.h> X#include <string.h> X#include <ctype.h> X#include <stdlib.h> X Xint Xmain(ac,av) Xint ac; Xchar **av; X{ X FILE *fp; X int i = 0,r,v,f=0; X char buff[100],*line[100],*p; X X if (ac == 2 && strcmp(av[1],"-v") == 0) X f = 1; X if (!(fp = fopen("sreg_version.i","r+"))) { X puts("Unable to open input."); X return 30; X } X X while (fgets(buff,100,fp) == buff) X line[i++] = strdup(buff); X line[i] = NULL; X X fseek(fp,0,SEEK_SET); X for (i = 0; line[i]; i++) { X if (strncmp(line[i],"VERSION",7) == 0) { X p = line[i]; X while (!isdigit(*p)) p++; X v = atoi(p); X if (f) { X v++; X sprintf(p,"%d\n",v); X } X } else X if (strncmp(line[i],"REVISION",8) == 0) { X p = line[i]; X while (!isdigit(*p)) p++; X r = atoi(p)+1; X if (f) X r = 0; X sprintf(p,"%d\n",r); X } X fputs(line[i],fp); X } X fclose(fp); X if (!(fp = fopen("sreg_version.c","w"))) { X puts("Unable to open c file."); X return 10; X } X fprintf(fp, X"\n\nconst __far char idString[] = \"sreglib %d.%d (\"__DATE__\")\\x0d\\x0a\";\n" X,v,r); X fclose(fp); X printf("Up to version %d.%d\n",v,r); X return 0; X} END_OF_FILE if test 1133 -ne `wc -c <'utils/bumprev.c'`; then echo shar: \"'utils/bumprev.c'\" unpacked with wrong size! fi # end of 'utils/bumprev.c' fi if test -f 'utils/remlib.c' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'utils/remlib.c'\" else echo shar: Extracting \"'utils/remlib.c'\" $523 characters$ sed "s/^X//" >'utils/remlib.c' <<'END_OF_FILE' X X#include <exec/types.h> X#include <exec/libraries.h> X#include <clib/exec_protos.h> X#include <exec/execbase.h> X#include <stdio.h> X#include <stdlib.h> X Xextern struct ExecBase *SysBase; X Xint Xmain(ac,av) Xint ac; Xchar **av; X{ X struct Library *found; X X if (ac != 2) { X puts("Use: remlib <library name>"); X return 10; X } X X Forbid(); X if (found = (struct Library *)FindName(&SysBase->LibList,av[1])) X RemLibrary(found); X Permit(); X if (!found) X return 5; X puts("OK, hopefully it is gone."); X return 0; X} END_OF_FILE if test 523 -ne `wc -c <'utils/remlib.c'`; then echo shar: \"'utils/remlib.c'\" unpacked with wrong size! fi # end of 'utils/remlib.c' fi if test -f 'utils/try.c' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'utils/try.c'\" else echo shar: Extracting \"'utils/try.c'\" $1755 characters$ sed "s/^X//" >'utils/try.c' <<'END_OF_FILE' X X#include "sregexpbase.h" X#include "sregexp_protos.h" X#include <libraries/dos.h> X#include <clib/exec_protos.h> X#include <clib/dos_protos.h> X#include <string.h> X#include <assert.h> X#include <stdlib.h> X Xstruct SregExpBase *SregExpBase; X Xvoid Xputs(c) Xchar *c; X{ Xchkabort(); X Write(Output(),c,strlen(c)); X Write(Output(),"\n",1); X} X X#include <stdarg.h> X Xextern void vsprintf(char *, char *, va_list); X Xvoid printf(f, ...) Xchar *f; X{ X char buff[100]; X va_list va; X Xchkabort(); X va_start(va,f); X vsprintf(buff,f,va); X va_end(va); X Write(Output(),buff,strlen(buff)); X} X Xint Xbrk() X{ /* Don't worry about lost memory for now... */ X XWrite(Output(),"BREAK\n",6); X CloseLibrary(SregExpBase); X return 1; X X} X Xint Xmain(ac,av) Xint ac; Xchar *av; X{ X struct SregExp *pat; X struct SpathInfo *spi; X char buff[300],fb[110]; X BPTR lock; X X if (!(SregExpBase = OpenLibrary("sregexp.library",0))) { X puts("Unable to open library."); X return 5; X } X onbreak(brk); X/* X assert(pat = ParseSregExp("#?dog")); X X if (MatchSregExp("hello dog",pat,1)) X puts("right"); X else X puts("wrong"); X X if (MatchSregExp("hello Dog",pat,1)) X puts("right"); X else X puts("wrong"); X X if (MatchSregExp("hello Dog",pat,0)) X puts("right"); X else X puts("wrong"); X X if (MatchSregExp("hello cat",pat,1)) X puts("right"); X else X puts("wrong"); X X FreeSregExp(pat); X*/ X assert(pat = ParseSregExp("(Programs|Shell)")); X X if (!(spi = AnchorPath("","DCC:#?/dme.refs"))) { X puts("Couldn't start search."); X CloseLibrary(SregExpBase); X return 10; X } Xputs("Path anchored"); X while (NextFile(spi,buff,300,0) != SPE_ALL_DONE) { X printf("----------> %s\n",buff); X } X X FreeSpathInfo(spi); X X CloseLibrary(SregExpBase); X} END_OF_FILE if test 1755 -ne `wc -c <'utils/try.c'`; then echo shar: \"'utils/try.c'\" unpacked with wrong size! fi # end of 'utils/try.c' fi echo shar: End of archive 1 $of 2$. cp /dev/null ark1isdone MISSING="" for I in 1 2 ; do if test ! -f ark${I}isdone ; then MISSING="${MISSING} ${I}" fi done if test "${MISSING}" = "" ; then echo You have unpacked both archives. rm -f ark[1-9]isdone else echo You still need to unpack the following archives: echo " " ${MISSING} fi ## End of shell archive. exit 0 -- Mail submissions (sources or binaries) to <amiga@uunet.uu.net>. Mail comments to the moderator at <amiga-request@uunet.uu.net>. Post requests for sources, and general discussion to comp.sys.amiga.misc.